( function () {
class CinematicCamera extends THREE.PerspectiveCamera {
  constructor(fov, aspect, near, far) {
    super(fov, aspect, near, far);
    this.type = 'CinematicCamera';
    this.postprocessing = {
      enabled: true
    };
    this.shaderSettings = {
      rings: 3,
      samples: 4
    };
    const depthShader = THREE.BokehDepthShader;
    this.materialDepth = new THREE.ShaderMaterial({
      uniforms: depthShader.uniforms,
      vertexShader: depthShader.vertexShader,
      fragmentShader: depthShader.fragmentShader
    });
    this.materialDepth.uniforms['mNear'].value = near;
    this.materialDepth.uniforms['mFar'].value = far; // In case of cinematicCamera, having a default lens set is important

    this.setLens();
    this.initPostProcessing();
  } // providing fnumber and coc(Circle of Confusion) as extra arguments
  // In case of cinematicCamera, having a default lens set is important
  // if fnumber and coc are not provided, cinematicCamera tries to act as a basic THREE.PerspectiveCamera


  setLens(focalLength = 35, filmGauge = 35, fNumber = 8, coc = 0.019) {
    this.filmGauge = filmGauge;
    this.setFocalLength(focalLength);
    this.fNumber = fNumber;
    this.coc = coc; // fNumber is focalLength by aperture

    this.aperture = focalLength / this.fNumber; // hyperFocal is required to calculate depthOfField when a lens tries to focus at a distance with given fNumber and focalLength

    this.hyperFocal = focalLength * focalLength / (this.aperture * this.coc);
  }

  linearize(depth) {
    const zfar = this.far;
    const znear = this.near;
    return -zfar * znear / (depth * (zfar - znear) - zfar);
  }

  smoothstep(near, far, depth) {
    const x = this.saturate((depth - near) / (far - near));
    return x * x * (3 - 2 * x);
  }

  saturate(x) {
    return Math.max(0, Math.min(1, x));
  } // function for focusing at a distance from the camera


  focusAt(focusDistance = 20) {
    const focalLength = this.getFocalLength(); // distance from the camera (normal to frustrum) to focus on

    this.focus = focusDistance; // the nearest point from the camera which is in focus (unused)

    this.nearPoint = this.hyperFocal * this.focus / (this.hyperFocal + (this.focus - focalLength)); // the farthest point from the camera which is in focus (unused)

    this.farPoint = this.hyperFocal * this.focus / (this.hyperFocal - (this.focus - focalLength)); // the gap or width of the space in which is everything is in focus (unused)

    this.depthOfField = this.farPoint - this.nearPoint; // Considering minimum distance of focus for a standard lens (unused)

    if (this.depthOfField < 0) this.depthOfField = 0;
    this.sdistance = this.smoothstep(this.near, this.far, this.focus);
    this.ldistance = this.linearize(1 - this.sdistance);
    this.postprocessing.bokeh_uniforms['focalDepth'].value = this.ldistance;
  }

  initPostProcessing() {
    if (this.postprocessing.enabled) {
      this.postprocessing.scene = new THREE.Scene();
      this.postprocessing.camera = new THREE.OrthographicCamera(window.innerWidth / -2, window.innerWidth / 2, window.innerHeight / 2, window.innerHeight / -2, -10000, 10000);
      this.postprocessing.scene.add(this.postprocessing.camera);
      const pars = {
        minFilter: THREE.LinearFilter,
        magFilter: THREE.LinearFilter,
        format: THREE.RGBFormat
      };
      this.postprocessing.rtTextureDepth = new THREE.WebGLRenderTarget(window.innerWidth, window.innerHeight, pars);
      this.postprocessing.rtTextureColor = new THREE.WebGLRenderTarget(window.innerWidth, window.innerHeight, pars);
      const bokeh_shader = THREE.BokehShader;
      this.postprocessing.bokeh_uniforms = THREE.UniformsUtils.clone(bokeh_shader.uniforms);
      this.postprocessing.bokeh_uniforms['tColor'].value = this.postprocessing.rtTextureColor.texture;
      this.postprocessing.bokeh_uniforms['tDepth'].value = this.postprocessing.rtTextureDepth.texture;
      this.postprocessing.bokeh_uniforms['manualdof'].value = 0;
      this.postprocessing.bokeh_uniforms['shaderFocus'].value = 0;
      this.postprocessing.bokeh_uniforms['fstop'].value = 2.8;
      this.postprocessing.bokeh_uniforms['showFocus'].value = 1;
      this.postprocessing.bokeh_uniforms['focalDepth'].value = 0.1; //console.log( this.postprocessing.bokeh_uniforms[ "focalDepth" ].value );

      this.postprocessing.bokeh_uniforms['znear'].value = this.near;
      this.postprocessing.bokeh_uniforms['zfar'].value = this.near;
      this.postprocessing.bokeh_uniforms['textureWidth'].value = window.innerWidth;
      this.postprocessing.bokeh_uniforms['textureHeight'].value = window.innerHeight;
      this.postprocessing.materialBokeh = new THREE.ShaderMaterial({
        uniforms: this.postprocessing.bokeh_uniforms,
        vertexShader: bokeh_shader.vertexShader,
        fragmentShader: bokeh_shader.fragmentShader,
        defines: {
          RINGS: this.shaderSettings.rings,
          SAMPLES: this.shaderSettings.samples,
          DEPTH_PACKING: 1
        }
      });
      this.postprocessing.quad = new THREE.Mesh(new THREE.PlaneGeometry(window.innerWidth, window.innerHeight), this.postprocessing.materialBokeh);
      this.postprocessing.quad.position.z = -500;
      this.postprocessing.scene.add(this.postprocessing.quad);
    }
  }

  renderCinematic(scene, renderer) {
    if (this.postprocessing.enabled) {
      const currentRenderTarget = renderer.getRenderTarget();
      renderer.clear(); // Render scene into texture

      scene.overrideMaterial = null;
      renderer.setRenderTarget(this.postprocessing.rtTextureColor);
      renderer.clear();
      renderer.render(scene, this); // Render depth into texture

      scene.overrideMaterial = this.materialDepth;
      renderer.setRenderTarget(this.postprocessing.rtTextureDepth);
      renderer.clear();
      renderer.render(scene, this); // Render bokeh composite

      renderer.setRenderTarget(null);
      renderer.render(this.postprocessing.scene, this.postprocessing.camera);
      renderer.setRenderTarget(currentRenderTarget);
    }
  }

}

THREE.CinematicCamera = CinematicCamera;
} )();
